Android
Testing
Mastery

@RunWith(AndroidJUnit4::class)
@SmallTest
class UserDaoTest {

    private lateinit var database: AppDatabase
    private lateinit var userDao: UserDao

    @Before
    fun createDb() {
        val context = ApplicationProvider.getApplicationContext<Context>()
        database = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
            .allowMainThreadQueries()
            .build()
        userDao = database.userDao()
    }

    @After
    fun closeDb() = database.close()

    @Test
    fun insertAndRetrieveUser() = runTest {
        val user = UserEntity(id = "1", name = "Alice", email = "alice@test.com")

        userDao.insert(user)

        val retrieved = userDao.getUserById("1")
        assertThat(retrieved).isEqualTo(user)
    }

    @Test
    fun updateUserEmitsNewValue() = runTest {
        val user = UserEntity(id = "2", name = "Bob", email = "bob@test.com")
        userDao.insert(user)

        userDao.update(user.copy(name = "Bobby"))

        userDao.observeUser("2").test {
            assertThat(awaitItem().name).isEqualTo("Bobby")
            cancelAndConsumeRemainingEvents()
        }
    }

    @Test
    fun deleteUserRemovesFromDb() = runTest {
        val user = UserEntity(id = "3", name = "Carol", email = "carol@test.com")
        userDao.insert(user)
        userDao.delete(user)

        assertThat(userDao.getUserById("3")).isNull()
    }
}

@RunWith(AndroidJUnit4::class)
@LargeTest
class LoginActivityTest {

    @get:Rule
    val activityRule = ActivityScenarioRule(LoginActivity::class.java)

    @Test
    fun successfulLogin_navigatesToHome() {
        // Type credentials
        onView(withId(R.id.emailField))
            .perform(typeText("user@test.com"), closeSoftKeyboard())

        onView(withId(R.id.passwordField))
            .perform(typeText("password123"), closeSoftKeyboard())

        // Click login
        onView(withId(R.id.loginButton))
            .perform(click())

        // Verify navigation to HomeActivity
        intended(hasComponent(HomeActivity::class.java.name))
    }

    @Test
    fun emptyEmail_showsErrorMessage() {
        onView(withId(R.id.loginButton)).perform(click())

        onView(withText("Email cannot be empty"))
            .check(matches(isDisplayed()))
    }

    @Test
    fun recyclerItem_click_opensDetail() {
        onView(withId(R.id.recyclerView))
            .perform(RecyclerViewActions
                .actionOnItemAtPosition<UserAdapter.ViewHolder>(0, click()))

        onView(withId(R.id.detailContainer))
            .check(matches(isDisplayed()))
    }
}

class ProfileScreenTest {

    @get:Rule
    val composeTestRule = createComposeRule()

    @Test
    fun profileScreen_displaysUserName() {
        composeTestRule.setContent {
            ProfileScreen(user = User(name = "Alice", bio = "Android Developer"))
        }

        composeTestRule.onNodeWithText("Alice").assertIsDisplayed()
        composeTestRule.onNodeWithText("Android Developer").assertIsDisplayed()
    }

    @Test
    fun editButton_click_togglesEditMode() {
        composeTestRule.setContent {
            ProfileScreen(user = User(name = "Alice"))
        }

        composeTestRule.onNodeWithContentDescription("Edit profile").performClick()

        composeTestRule.onNodeWithTag("nameInput").assertIsDisplayed()
        composeTestRule.onNodeWithTag("nameInput").assertTextContains("Alice")
    }

    @Test
    fun loadingState_showsProgressIndicator() {
        composeTestRule.setContent {
            ProfileScreen(uiState = ProfileUiState.Loading)
        }

        composeTestRule.onNodeWithTag("loadingIndicator").assertIsDisplayed()
        composeTestRule.onNodeWithText("Alice").assertDoesNotExist()
    }

    @Test
    fun semanticsCheck_allImagesHaveContentDescription() {
        composeTestRule.setContent {
            ProfileScreen(user = User(avatarUrl = "https://..."))
        }

        composeTestRule
            .onAllNodesWithContentDescription("Profile avatar")
            .assertAll(isDisplayed())
    }
}

class FeedViewModelTest {

    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()

    private val feedRepository = mockk<FeedRepository>()
    private lateinit var viewModel: FeedViewModel

    @Before
    fun setUp() {
        viewModel = FeedViewModel(feedRepository)
    }

    @Test
    fun `feed items flow emits loading then content`() = runTest {
        val items = listOf(FeedItem("1"), FeedItem("2"))
        coEvery { feedRepository.observeFeed() } returns flowOf(items)

        viewModel.feedItems.test {
            // Initial loading state
            assertThat(awaitItem()).isInstanceOf(FeedUiState.Loading::class.java)

            // Content state
            val content = awaitItem() as FeedUiState.Content
            assertThat(content.items).hasSize(2)

            cancelAndConsumeRemainingEvents()
        }
    }

    @Test
    fun `refresh triggers new fetch`() = runTest {
        coEvery { feedRepository.refresh() } returns Unit

        viewModel.refresh()

        coVerify(exactly = 1) { feedRepository.refresh() }
    }
}

@HiltAndroidTest
@RunWith(AndroidJUnit4::class)
class MainActivityHiltTest {

    @get:Rule(order = 0)
    val hiltRule = HiltAndroidRule(this)

    @get:Rule(order = 1)
    val activityRule = ActivityScenarioRule(MainActivity::class.java)

    // Replace real dep with a fake
    @BindValue @JvmField
    val authRepository: AuthRepository = mockk(relaxed = true)

    @Before
    fun init() = hiltRule.inject()

    @Test
    fun loggedOutUser_seesLoginScreen() {
        every { authRepository.isLoggedIn() } returns false

        onView(withId(R.id.loginScreen))
            .check(matches(isDisplayed()))
    }

    @Test
    fun loggedInUser_seesHomeScreen() {
        every { authRepository.isLoggedIn() } returns true

        onView(withId(R.id.homeScreen))
            .check(matches(isDisplayed()))
    }
}

@RunWith(AndroidJUnit4::class)
class AppStartupBenchmark {

    @get:Rule
    val benchmarkRule = MacrobenchmarkRule()

    @Test
    fun startupCold() = benchmarkRule.measureRepeated(
        packageName = "com.example.myapp",
        metrics = listOf(StartupTimingMetric()),
        iterations = 5,
        startupMode = StartupMode.COLD,
    ) {
        pressHome()
        startActivityAndWait()
    }

    @Test
    fun scrollFeedJankMetrics() = benchmarkRule.measureRepeated(
        packageName = "com.example.myapp",
        metrics = listOf(FrameTimingMetric()),
        iterations = 3,
        startupMode = StartupMode.WARM,
        setupBlock = { startActivityAndWait() }
    ) {
        val device = device()
        val recycler = device.findObject(By.res("com.example.myapp:id/feedList"))
        recycler.setGestureMargin(device.displayWidth / 5)
        recycler.fling(Direction.DOWN)
    }
}